//
//  UserModel.swift
//  LivelyChat
//
//  Created by admin on 2021/6/23.
//

import UIKit
import AVFoundation

var USEINFOMODEL = InfoUtil.initInfo()
class UserModel: NSObject {

    func getUUID()->String{
        return HSSKeychain.getData()
    }
    
    class func getAge(birthdayStr:String) ->String?{
        let date = NSDate()
        let timeFormatter = DateFormatter()
        timeFormatter.dateFormat = "yyyy-MM-dd"
        let strNowTime = timeFormatter.string(from: date as Date)
        let index = birthdayStr.index(birthdayStr.startIndex, offsetBy: 4)
        let index1 = strNowTime.index(strNowTime.startIndex, offsetBy: 4)
        let str1 = String(birthdayStr.prefix(upTo: index))
        let str2 = String(strNowTime.prefix(upTo: index1))
        return String(Int(str2)! - Int(str1)!)
    }


    func iphoneType() ->String {
           
           var systemInfo = utsname()
           uname(&systemInfo)
           
           let platform = withUnsafePointer(to: &systemInfo.machine.0) { ptr in
                   return String(cString: ptr)
               }
           
           if platform == "iPhone1,1" { return "iPhone 2G"}
           if platform == "iPhone1,2" { return "iPhone 3G"}
           if platform == "iPhone2,1" { return "iPhone 3GS"}
           if platform == "iPhone3,1" { return "iPhone 4"}
           if platform == "iPhone3,2" { return "iPhone 4"}
           if platform == "iPhone3,3" { return "iPhone 4"}
           if platform == "iPhone4,1" { return "iPhone 4S"}
           if platform == "iPhone5,1" { return "iPhone 5"}
           if platform == "iPhone5,2" { return "iPhone 5"}
           if platform == "iPhone5,3" { return "iPhone 5C"}
           if platform == "iPhone5,4" { return "iPhone 5C"}
           if platform == "iPhone6,1" { return "iPhone 5S"}
           if platform == "iPhone6,2" { return "iPhone 5S"}
           if platform == "iPhone7,1" { return "iPhone 6 Plus"}
           if platform == "iPhone7,2" { return "iPhone 6"}
           if platform == "iPhone8,1" { return "iPhone 6S"}
           if platform == "iPhone8,2" { return "iPhone 6S Plus"}
           if platform == "iPhone8,4" { return "iPhone SE"}
           if platform == "iPhone9,1" { return "iPhone 7"}
           if platform == "iPhone9,2" { return "iPhone 7 Plus"}
           if platform == "iPhone10,1" { return "iPhone 8"}
           if platform == "iPhone10,2" { return "iPhone 8 Plus"}
           if platform == "iPhone10,3" { return "iPhone X"}
           if platform == "iPhone10,4" { return "iPhone 8"}
           if platform == "iPhone10,5" { return "iPhone 8 Plus"}
           if platform == "iPhone10,6" { return "iPhone X"}
           if platform == "iPhone11,2" { return "iPhone XS"}
           if platform == "iPhone11,4" { return "iPhone XS Max"}
           if platform == "iPhone11,6" { return "iPhone XS Max"}
           if platform == "iPhone11,8" { return "iPhone XR"}
           if platform == "iPhone12,1" { return "iPhone 11"}
           if platform == "iPhone12,3" { return "iPhone 11 Pro"}
           if platform == "iPhone12,5" { return "iPhone 11 Pro Max"}
           if platform == "iPhone13,1" { return "iPhone 12 mini"}
           if platform == "iPhone13,2" { return "iPhone 12"}
           if platform == "iPhone13,3" { return "iPhone 12  Pro"}
           if platform == "iPhone13,4" { return "iPhone 12  Pro Max"}
           
           if platform == "iPod1,1" { return "iPod Touch 1G"}
           if platform == "iPod2,1" { return "iPod Touch 2G"}
           if platform == "iPod3,1" { return "iPod Touch 3G"}
           if platform == "iPod4,1" { return "iPod Touch 4G"}
           if platform == "iPod5,1" { return "iPod Touch 5G"}
           
           if platform == "iPad1,1" { return "iPad 1"}
           if platform == "iPad2,1" { return "iPad 2"}
           if platform == "iPad2,2" { return "iPad 2"}
           if platform == "iPad2,3" { return "iPad 2"}
           if platform == "iPad2,4" { return "iPad 2"}
           if platform == "iPad2,5" { return "iPad Mini 1"}
           if platform == "iPad2,6" { return "iPad Mini 1"}
           if platform == "iPad2,7" { return "iPad Mini 1"}
           if platform == "iPad3,1" { return "iPad 3"}
           if platform == "iPad3,2" { return "iPad 3"}
           if platform == "iPad3,3" { return "iPad 3"}
           if platform == "iPad3,4" { return "iPad 4"}
           if platform == "iPad3,5" { return "iPad 4"}
           if platform == "iPad3,6" { return "iPad 4"}
           if platform == "iPad4,1" { return "iPad Air"}
           if platform == "iPad4,2" { return "iPad Air"}
           if platform == "iPad4,3" { return "iPad Air"}
           if platform == "iPad4,4" { return "iPad Mini 2"}
           if platform == "iPad4,5" { return "iPad Mini 2"}
           if platform == "iPad4,6" { return "iPad Mini 2"}
           if platform == "iPad4,7" { return "iPad Mini 3"}
           if platform == "iPad4,8" { return "iPad Mini 3"}
           if platform == "iPad4,9" { return "iPad Mini 3"}
           if platform == "iPad5,1" { return "iPad Mini 4"}
           if platform == "iPad5,2" { return "iPad Mini 4"}
           if platform == "iPad5,3" { return "iPad Air 2"}
           if platform == "iPad5,4" { return "iPad Air 2"}
           if platform == "iPad6,3" { return "iPad Pro 9.7"}
           if platform == "iPad6,4" { return "iPad Pro 9.7"}
           if platform == "iPad6,7" { return "iPad Pro 12.9"}
           if platform == "iPad6,8" { return "iPad Pro 12.9"}
           
           if platform == "i386"   { return "iPhone Simulator"}
           if platform == "x86_64" { return "iPhone Simulator"}
           
           return platform
           
       }
    
    //MARK: - 获取当前时间的时间戳
    class func getTimeCHUO()->Int {
        let now = NSDate()
        let timeInterval: TimeInterval = now.timeIntervalSince1970
        let timeStamp = CLongLong(round(timeInterval*1000))
        return Int(timeStamp)
    }

}


extension UIImage {
    func compressImage() -> UIImage {
        let tempMaxLength: Int = 2048 / 8
        var compression: CGFloat = 1
        guard var data = self.jpegData(compressionQuality: compression), data.count > tempMaxLength else { return self }
        var max: CGFloat = 1
        var min: CGFloat = 0
        for _ in 0..<6 {
            compression = (max + min) / 2
            data = self.jpegData(compressionQuality: compression)!
            if CGFloat(data.count) < CGFloat(tempMaxLength) * 0.9 {
                min = compression
            } else if data.count > tempMaxLength {
                max = compression
            } else {
                break
            }
        }
        var resultImage: UIImage = UIImage(data: data)!
        if data.count < tempMaxLength { return resultImage }
        var lastDataLength: Int = 0
        while data.count > tempMaxLength && data.count != lastDataLength {
            lastDataLength = data.count
            let ratio: CGFloat = CGFloat(tempMaxLength) / CGFloat(data.count)
            print("Ratio =", ratio)
            let size: CGSize = CGSize(width: Int(resultImage.size.width * sqrt(ratio)),
                                      height: Int(resultImage.size.height * sqrt(ratio)))
            UIGraphicsBeginImageContext(size)
            resultImage.draw(in: CGRect(x: 0, y: 0, width: size.width, height: size.height))
            resultImage = UIGraphicsGetImageFromCurrentImageContext()!
            UIGraphicsEndImageContext()
            data = self.jpegData(compressionQuality: compression)!
        }
        return resultImage
    }
    func resetImgSize() -> Data {
        var maxSize:CGFloat = 1024.0
        var maxImageSize:CGFloat = 1024.0
        if (maxSize <= 0.0) {
            maxSize = 1024.0
        }
        if (maxImageSize <= 0.0)  {
            maxImageSize = 1024.0
        }
        var newSize = CGSize.init(width: self.size.width, height: self.size.height)
        let tempHeight = newSize.height / maxImageSize
        let tempWidth = newSize.width / maxImageSize
        if (tempWidth > 1.0 && tempWidth > tempHeight) {
            newSize = CGSize.init(width: self.size.width / tempWidth, height: self.size.height / tempWidth)
        }
        else if (tempHeight > 1.0 && tempWidth < tempHeight){
            newSize = CGSize.init(width: self.size.width / tempHeight, height: self.size.height / tempHeight)
        }
        UIGraphicsBeginImageContext(newSize)
        self.draw(in: CGRect.init(x: 0, y: 0, width: newSize.width, height: newSize.height))
        let newImage = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()
        var imageData = newImage!.jpegData(compressionQuality: 1.0)
        var sizeOriginKB : CGFloat = CGFloat((imageData?.count)!) / 1024.0
        var resizeRate = 0.9
        while (sizeOriginKB > maxSize && resizeRate > 0.1) {
            imageData = newImage!.jpegData(compressionQuality: CGFloat(resizeRate))
            sizeOriginKB = CGFloat((imageData?.count)!) / 1024.0
            resizeRate -= 0.1
        }
        return imageData!
    }
}


extension UITableView
{
    func addEmptView() -> Void {
        let view = UIView(frame: self.bounds)
        let img = UIImageView(frame: CGRect(x: screenWidth/2 - 150/2, y: 40, width: 150, height: 150))
        img.image = UIImage(named: "Illus")
        view.addSubview(img)
        let label = UILabel(frame: CGRect(x: 0, y: 200, width: screenWidth, height: 20))
        label.text = "list is empty."
        label.textAlignment = .center
        label.textColor = .color(hexString: "#7B7890")
        label.font = UIFont.systemFont(ofSize: 16)
        view.addSubview(label)
        self.addSubview(view)
    }
    
    func removeEmptyView() -> Void {
        for view in self.subviews {
            view.removeFromSuperview()
        }
    }
}


extension UIViewController
{
    // MARK: - 把秒数转换成时分秒（00:00:00）格式
    ///
    /// - Parameter time: time(Float格式)
    /// - Returns: String格式(00:00:00)
    func transToHourMinSec(time: Float) -> String
    {
        let allTime: Int = Int(time)
        var hours = 0
        var minutes = 0
        var seconds = 0
        var hoursText = ""
        var minutesText = ""
        var secondsText = ""
        hours = allTime / 3600
        hoursText = hours > 9 ? "\(hours)" : "0\(hours)"
        
        minutes = allTime % 3600 / 60
        minutesText = minutes > 9 ? "\(minutes)" : "0\(minutes)"
        
        seconds = allTime % 3600 % 60
        secondsText = seconds > 9 ? "\(seconds)" : "0\(seconds)"
        return "\(minutesText):\(secondsText)"
    }
    
    func transTimeInt(time: String) -> Int
    {
        let arr = time.components(separatedBy: ":")
        let str : String = arr.first ?? "0"
        let time = (Int(str) ?? 0) * 60 + (Int(arr.last ?? "0") ?? 0)
        return time
    }
    
    func requestCaptureAuthorizationByMediaType(mediaType:String) -> Bool{
        var isVideo = false
        switch (AVCaptureDevice.authorizationStatus(for: AVMediaType.video)) {
        case AVAuthorizationStatus.authorized:
            isVideo = true
            
        case AVAuthorizationStatus.notDetermined:
            
            let somapr = DispatchSemaphore(value: 0)
            AVCaptureDevice.requestAccess(for: AVMediaType.video) { (granted) in
                isVideo = granted
                somapr.signal()
            }
            
            somapr.wait()
            
        default:
            isVideo = false
        }
        
        return  isVideo
    }
            
    func requestCaptureAuthorizationByMicf() -> Bool{
        // 麦克风权限
        var isMic = false
        let permissionStatus = AVAudioSession.sharedInstance().recordPermission
        if permissionStatus == AVAudioSession.RecordPermission.undetermined {

            let somapr = DispatchSemaphore(value: 0)
            AVAudioSession.sharedInstance().requestRecordPermission { (granted) in
                isMic = granted
                somapr.signal()
            }
            somapr.wait()
        } else if permissionStatus == AVAudioSession.RecordPermission.denied {
            isMic = false
        } else {
            isMic = true
        }
        return  isMic
    }

}
